{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7e2acac5",
   "metadata": {},
   "source": [
    "### Exact solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "cab77013",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.io\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# Load the .mat file\n",
    "mat_data = scipy.io.loadmat('Allen_Cahn.mat')\n",
    "\n",
    "# Following is the code to plot the data u vs x and t. u is 256*100\n",
    "# matrix. Use first 75 columns for training and 25 for testing :)\n",
    "\n",
    "# Access the variables stored in the .mat file\n",
    "# The variable names in the .mat file become keys in the loaded dictionary\n",
    "x = mat_data['x']\n",
    "t = mat_data['t']\n",
    "u = mat_data['u']\n",
    "\n",
    "# # Use the loaded variables as needed\n",
    "# print(x.shape)\n",
    "# print(t.shape)\n",
    "# print(u.shape)\n",
    "\n",
    "# X, T = np.meshgrid(x, t)\n",
    "# # Define custom color levels\n",
    "# c_levels = np.linspace(np.min(u), np.max(u), 100)\n",
    "\n",
    "# # Plot the contour\n",
    "# plt.figure()\n",
    "# plt.figure(figsize=(15, 5))\n",
    "# plt.contourf(T, X, u, levels=c_levels, cmap='coolwarm')\n",
    "# plt.xlabel('t')\n",
    "# plt.ylabel('x')\n",
    "# plt.title('Allen-cahn-Equation')\n",
    "# plt.colorbar()  # Add a colorbar for the contour levels\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84bf073b",
   "metadata": {},
   "source": [
    "### PINN data importing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1b028244",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(20301, 2)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.io\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# Load the .mat file\n",
    "mat_data = scipy.io.loadmat('X.mat')\n",
    "\n",
    "X = mat_data['X']\n",
    "\n",
    "mat_data1 = scipy.io.loadmat('y_pred.mat')\n",
    "\n",
    "u1 = mat_data1['y_pred']\n",
    "\n",
    "np.set_printoptions(threshold=np.inf)\n",
    "\n",
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "27f7472a",
   "metadata": {},
   "outputs": [],
   "source": [
    "### Reshaping the solution\n",
    "\n",
    "u1 = u1.reshape(101, 201)\n",
    "u1_new = u1.T\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d177a69d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(201, 101)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u1_new.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a82fd0d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tani (20301, 1)\n"
     ]
    }
   ],
   "source": [
    "# Load the .mat file\n",
    "mat_data2 = scipy.io.loadmat('y_true.mat')\n",
    "\n",
    "u2 = mat_data2['y_true']\n",
    "print(\"tani\", u2.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ed5635ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "# importing libaries\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.io"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f74caeb0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LEMCell(nn.Module):\n",
    "    def __init__(self, ninp, nhid, dt):\n",
    "        super(LEMCell, self).__init__()\n",
    "        self.ninp = ninp\n",
    "        self.nhid = nhid\n",
    "        self.dt = dt\n",
    "        self.inp2hid = nn.Linear(ninp, 4 * nhid)\n",
    "        self.hid2hid = nn.Linear(nhid, 3 * nhid)\n",
    "        self.transform_z = nn.Linear(nhid, nhid)\n",
    "        self.reset_parameters()\n",
    "\n",
    "    def reset_parameters(self):\n",
    "        std = 1.0 / np.sqrt(self.nhid)\n",
    "        for w in self.parameters():\n",
    "            w.data.uniform_(-std, std)\n",
    "\n",
    "    def forward(self, x, y, z):\n",
    "        transformed_inp = self.inp2hid(x)\n",
    "        transformed_hid = self.hid2hid(y)\n",
    "        i_dt1, i_dt2, i_z, i_y = transformed_inp.chunk(4, 1)\n",
    "        h_dt1, h_dt2, h_y = transformed_hid.chunk(3, 1)\n",
    "\n",
    "        ms_dt_bar = self.dt * torch.sigmoid(i_dt1 + h_dt1)\n",
    "        ms_dt = self.dt * torch.sigmoid(i_dt2 + h_dt2)\n",
    "\n",
    "        z = (1. - ms_dt) * z + ms_dt * torch.tanh(i_y + h_y)\n",
    "        y = (1. - ms_dt_bar) * y + ms_dt_bar * torch.tanh(self.transform_z(z) + i_z)\n",
    "\n",
    "        return y, z\n",
    "\n",
    "# Define the LEM model\n",
    "class LEM(nn.Module):\n",
    "    def __init__(self, ninp, nhid, nout, dt=1.):\n",
    "        super(LEM, self).__init__()\n",
    "        self.nhid = nhid\n",
    "        self.cell = LEMCell(ninp, nhid, dt)\n",
    "        self.classifier = nn.Linear(nhid, nout)\n",
    "        self.init_weights()\n",
    "\n",
    "    def init_weights(self):\n",
    "        for name, param in self.named_parameters():\n",
    "            if 'classifier' in name and 'weight' in name:\n",
    "                nn.init.kaiming_normal_(param.data)\n",
    "\n",
    "    def forward(self, input):\n",
    "        y = input.data.new(input.size(1), self.nhid).zero_()\n",
    "        z = input.data.new(input.size(1), self.nhid).zero_()\n",
    "        for x in input:\n",
    "            y, z = self.cell(x, y, z)\n",
    "        out = self.classifier(y)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1c60d23c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Toy problem data\n",
    "input_size = 201  # number of columns in a dataset\n",
    "hidden_size = 32  # number of neurons\n",
    "output_size = 201\n",
    "sequence_length = 80  # number of sequences/ number of rows\n",
    "batch_size = 1\n",
    "num_epochs = 200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0b0d588d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# data = scipy.io.loadmat('y_pred.mat')\n",
    "u1 = u1_new\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e9e2e9c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test data shape (201,)\n",
      "input data shape (201, 80)\n",
      "Target data shape (201, 80)\n"
     ]
    }
   ],
   "source": [
    "input_data = u1[:, 0:80]\n",
    "target_data = u1[:, 1:81]\n",
    "\n",
    "test_data = u1[:, 80] ### Change here\n",
    "#test_target = u1[:, 81:101]\n",
    "\n",
    "print(\"test data shape\", test_data.shape)\n",
    "#print(\"test target shape\", test_target.shape)\n",
    "\n",
    "print(\"input data shape\",input_data.shape)\n",
    "print(\"Target data shape\",target_data.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9c682113",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input tensor shape torch.Size([1, 80, 201])\n",
      "Target tensor shape torch.Size([1, 80, 201])\n"
     ]
    }
   ],
   "source": [
    "# Convert data to tensors\n",
    "input_tensor = torch.tensor(input_data.T).view(batch_size, sequence_length, input_size).float()\n",
    "target_tensor = torch.tensor(target_data.T).view(batch_size, sequence_length, output_size).float()\n",
    "\n",
    "print(\"input tensor shape\",input_tensor.shape)\n",
    "print(\"Target tensor shape\",target_tensor.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6910db13",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert test data to tensors\n",
    "test_tensor = torch.tensor(test_data.T).view(batch_size, 1, input_size).float()\n",
    "#test_target_tensor = torch.tensor(test_target.T).view(batch_size, 20, output_size).float()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1bbfd754",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/data/localhome/tkapoor/anaconda3/lib/python3.9/site-packages/torch/nn/modules/loss.py:530: UserWarning: Using a target size (torch.Size([1, 80, 201])) that is different to the input size (torch.Size([80, 201])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 10/200, Loss: 0.0001880300260382\n",
      "Epoch: 20/200, Loss: 0.0000316564801324\n",
      "Epoch: 30/200, Loss: 0.0000155788675329\n",
      "Epoch: 40/200, Loss: 0.0000056342300923\n",
      "Epoch: 50/200, Loss: 0.0000039639339775\n",
      "Epoch: 60/200, Loss: 0.0000036279138840\n",
      "Epoch: 70/200, Loss: 0.0000036238811845\n",
      "Epoch: 80/200, Loss: 0.0000036234071104\n",
      "Epoch: 90/200, Loss: 0.0000036234071104\n",
      "Epoch: 100/200, Loss: 0.0000036234071104\n",
      "Epoch: 110/200, Loss: 0.0000036234071104\n",
      "Epoch: 120/200, Loss: 0.0000036234071104\n",
      "Epoch: 130/200, Loss: 0.0000036234071104\n",
      "Epoch: 140/200, Loss: 0.0000036234071104\n",
      "Epoch: 150/200, Loss: 0.0000036234071104\n",
      "Epoch: 160/200, Loss: 0.0000036234071104\n",
      "Epoch: 170/200, Loss: 0.0000036234071104\n",
      "Epoch: 180/200, Loss: 0.0000036234071104\n",
      "Epoch: 190/200, Loss: 0.0000036234071104\n",
      "Epoch: 200/200, Loss: 0.0000036234071104\n"
     ]
    }
   ],
   "source": [
    "# # dt=0.25, 0.15\n",
    "lem = LEM(input_size, hidden_size, output_size, dt=0.25)\n",
    "\n",
    "# Loss and optimizer\n",
    "criterion = nn.MSELoss()\n",
    "optimizer = torch.optim.LBFGS(lem.parameters(), lr=0.1)\n",
    "\n",
    "# # Loss and optimizer\n",
    "# criterion = nn.MSELoss()\n",
    "# optimizer = torch.optim.Adam(lem.parameters(), lr=0.001)\n",
    "\n",
    "# Training loop\n",
    "for epoch in range(num_epochs):\n",
    "    def closure():\n",
    "        optimizer.zero_grad()\n",
    "        output = lem(input_tensor)\n",
    "        loss = criterion(output, target_tensor)\n",
    "        loss.backward()\n",
    "        return loss\n",
    "\n",
    "    optimizer.step(closure)\n",
    "\n",
    "    # Print progress\n",
    "    if (epoch + 1) % 10 == 0:\n",
    "        print(f'Epoch: {epoch + 1}/{num_epochs}, Loss: {closure().item():.16f}')\n",
    "\n",
    "    # Flatten prediction tensor\n",
    "    prediction = lem(input_tensor).view(-1).detach().numpy()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "78de0827",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 1, 201])\n",
      "torch.Size([1, 20, 201])\n"
     ]
    }
   ],
   "source": [
    "print(test_tensor.shape)\n",
    "prediction_tensor = torch.zeros(1, 20, 201).float()\n",
    "print(prediction_tensor.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "297a16fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 1, 201])\n",
      "(201, 1)\n",
      "(201, 1)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "with torch.no_grad():\n",
    "    prediction = lem(test_tensor)\n",
    "    prediction = prediction.view(1, 1, 201).float()\n",
    "    prediction_tensor[:, 0, :] = prediction\n",
    "    for i in range(19):\n",
    "        prediction = lem(prediction)\n",
    "        prediction = prediction.view(1, 1, 201).float()\n",
    "        prediction_tensor[:, i+1, :] = prediction\n",
    "        \n",
    "print(prediction.shape)\n",
    "\n",
    "final_out = prediction.detach().numpy().reshape(-1,1)\n",
    "final_true = u[-1,:].reshape(-1,1)\n",
    "\n",
    "print(final_out.shape)\n",
    "print(final_true.shape)\n",
    "\n",
    "x = x.reshape(-1, 1)\n",
    "\n",
    "plt.plot(x, final_out)\n",
    "plt.plot(x, final_true)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4b7206d",
   "metadata": {},
   "source": [
    "### error at final time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f25db352",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Relative Error Test:  0.009723107556742374 \n"
     ]
    }
   ],
   "source": [
    "# Convert NumPy arrays to PyTorch tensors\n",
    "final_out_tensor = torch.from_numpy(final_out)\n",
    "final_true_tensor = torch.from_numpy(final_true)\n",
    "# final_true_tensor = torch.abs(final_true_tensor)\n",
    "\n",
    "# Compute the relative L2 error norm (generalization error)\n",
    "relative_error_test = torch.mean((final_out_tensor - final_true_tensor)**2)/torch.mean(final_true_tensor**2)\n",
    "print(\"Relative Error Test: \", relative_error_test.item(), \"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dae20135",
   "metadata": {},
   "source": [
    "### Error in whole testing dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5eaf1fee",
   "metadata": {},
   "outputs": [],
   "source": [
    "# exact\n",
    "u_test = u\n",
    "u_test_full = u_test[80:100, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "20d9252f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(20, 201)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u_test_full.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "8d1fb210",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 20, 201])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prediction_tensor.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e445eba",
   "metadata": {},
   "source": [
    "### L2 norm "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89d4bc2d",
   "metadata": {},
   "source": [
    "### Changed prediction tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "ee9bf8bc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([20, 201])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "k1 = (prediction_tensor - u_test_full)**2\n",
    "u_test_full_tensor = torch.tensor(u_test_full**2)\n",
    "u_test_full_tensor.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "7a13682f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Relative Error Test:  0.0029508101568068304 %\n"
     ]
    }
   ],
   "source": [
    "# Compute the relative L2 error norm (generalization error)\n",
    "relative_error_test = torch.mean(k1)/ torch.mean(u_test_full_tensor)\n",
    "\n",
    "print(\"Relative Error Test: \", relative_error_test.item(), \"%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa356244",
   "metadata": {},
   "source": [
    "### Max absolute error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "d4df8fb1",
   "metadata": {},
   "outputs": [],
   "source": [
    "R_abs = torch.max(prediction-u_test_full)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "765c1b67",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0.1362, dtype=torch.float64)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R_abs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53123052",
   "metadata": {},
   "source": [
    "### mean absolute error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "39b783e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "R_mean = torch.mean(torch.abs(prediction - u_test_full))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "0e98bd87",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0.0282, dtype=torch.float64)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R_mean"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3e6557b",
   "metadata": {},
   "source": [
    "### Explained variance error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "f147aa3c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Explained Variance Score: 0.9969839761866542\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "a = prediction\n",
    "b = u_test_full\n",
    "# Assuming 'a' is your predicted values (model's predictions) and 'b' is the true values (ground truth)\n",
    "# Make sure 'a' and 'b' are PyTorch tensors\n",
    "b = torch.tensor(b)\n",
    "# Calculate the mean of 'b'\n",
    "mean_b = torch.mean(b)\n",
    "\n",
    "# Calculate the Explained Variance Score\n",
    "numerator = torch.var(b - a)  # Variance of the differences between 'b' and 'a'\n",
    "denominator = torch.var(b)    # Variance of 'b'\n",
    "evs = 1 - numerator / denominator\n",
    "\n",
    "print(\"Explained Variance Score:\", evs.item())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a2555b6",
   "metadata": {},
   "source": [
    "### Contour plot 80 PINN and 20 LEM solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "088f6ee2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([20, 201])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prediction_tensor = torch.squeeze(prediction_tensor)\n",
    "prediction_tensor.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "656a2d06",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 1, 201])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prediction.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "2cd25700",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 80, 201])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input_tensor.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "37ac5ef9",
   "metadata": {},
   "outputs": [],
   "source": [
    "conc_u = torch.squeeze(input_tensor)\n",
    "prediction_tensor = torch.squeeze(prediction_tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "249d001b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([100, 201])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "concatenated_tensor = torch.cat((conc_u, prediction_tensor), dim=0)\n",
    "\n",
    "concatenated_tensor.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "99f14a63",
   "metadata": {},
   "outputs": [],
   "source": [
    "t1 = np.linspace(0, 1 , 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b620cee4",
   "metadata": {},
   "source": [
    "#### Snapshots at particular time\n",
    "### t = 0.81, 0.99"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "767a1e8a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "b0f931ea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "\n",
    "# Create the figure and axis objects with reduced width\n",
    "fig, ax = plt.subplots(figsize=(5, 5))  # You can adjust the width (7 inches) and height (5 inches) as needed\n",
    "\n",
    "# # Make sure the font is Times Roman\n",
    "# plt.rcParams['font.family'] = 'Times New Roman'\n",
    "\n",
    "# # Perform the prediction\n",
    "# with torch.no_grad():\n",
    "#     prediction = lem(test_tensor)\n",
    "\n",
    "final_time_output = prediction_tensor[-2, :]\n",
    "final_out = final_time_output.detach().numpy().reshape(-1, 1)\n",
    "final_true = u[-2, :].reshape(-1, 1)\n",
    "\n",
    "# Plot the data with red and blue lines, one with dotted and one with solid style\n",
    "ax.plot(x, final_out, color='red', linestyle='dotted', linewidth=12, label='Prediction')\n",
    "ax.plot(x, final_true, color='blue', linestyle='solid', linewidth=7, label='True')\n",
    "\n",
    "# Set the axis labels with bold font weight\n",
    "ax.set_xlabel(r\"${x}$\", fontsize=26, color='black', fontdict={'weight': 'bold'})\n",
    "ax.set_ylabel(r\"${u(x, t)}$\", fontsize=26, color='black', fontdict={'weight': 'bold'})\n",
    "\n",
    "# Set the title with bold font weight\n",
    "ax.set_title(r\"${t = 0.99}$\", fontsize=26, color='black', fontweight='bold')\n",
    "\n",
    "# Set the number of ticks for x-axis and y-axis to 3\n",
    "ax.set_xticks([-1, 0, 1])\n",
    "ax.set_yticks([-1, 0, 1])\n",
    "\n",
    "# Set tick labels fontweight to bold and increase font size\n",
    "ax.tick_params(axis='both', which='major', labelsize=20, width=2, length=10)\n",
    "\n",
    "# # Set the fontweight for tick labels to bold\n",
    "# for tick in ax.get_xticklabels() + ax.get_yticklabels():\n",
    "#     tick.set_weight('bold')\n",
    "\n",
    "# Set the spines linewidth to bold\n",
    "ax.spines['top'].set_linewidth(2)\n",
    "ax.spines['right'].set_linewidth(2)\n",
    "ax.spines['bottom'].set_linewidth(2)\n",
    "ax.spines['left'].set_linewidth(2)\n",
    "\n",
    "\n",
    "# Increase font size for x and y axis numbers\n",
    "ax.tick_params(axis='both', which='major', labelsize=24)\n",
    "\n",
    "# Set the legend\n",
    "# ax.legend()\n",
    "\n",
    "plt.savefig('LEM_0.99_20.pdf', dpi=500, bbox_inches=\"tight\")\n",
    "\n",
    "# Show the plot\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "3ac2cc78",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAF2CAYAAAB3QMMiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAA+E0lEQVR4nO3deXxU5dn/8c8VEkICYccFQVHABajggiig4FJ3H621Wm21Wlurba3V2mpXtf1prX18aqtdta27Vmu1ttalblXBBZRFAZEiqKCygwkhhCTX74/7ZDKJc05mO2fmzFzv12teM5NzZs6dTOY719znPvcRVcUYY0z8VBS6AcYYY7JjAW6MMTFlAW6MMTFlAW6MMTFlAW6MMTFlAW6MMTFlAW5MhETkJBF5TERWiUiTiLwtIr8RkZF5eO4RIvJ/IjJfROpFpFlEPhSRx0XkHBHp4fM4EZG9ROQLIvJrEZklIltFREWkKdd2mfCIjQM3cScipwJ/AZqBPqq6rcBN+hgREeAW4Is+qzQAp6nqv7J8/pOAO4HeAau9DByjqhu6PHYEsMznMVtVtVc2bTLhswrclIL9vOs3ijG8Pd+lI7zvA8YD2wEnAsuBPsBfRGT3TJ9YRHYF7sGF92rgAmBPYHtgCnC/t+ok4PfdPN1K4EHg+UzbYaJnAW5KQXuAzyloK3yIyPbA97y7jwCfVdX5qrpGVR8GDgM240L86iw28WWgF9AGHK+qv1PVxaq6WlVnquqpwN+8dT8tIoO7PH4dcBKwo6oOU9WTgaezaIeJmAW4KQX7etdzC9mIAGfR0bXxfe3Sb6mqy4Cbvbsne4GfifHe9RJVneWzzp3edQXQqb9dVetV9e+q+mGG2zUFZgFuYklE+nk72RQY4P34xvafeZdVhWxjkhO86yWqOs9nnb961xXAsRk+f/uOxraAdZKXrcnw+U2RsgA3cTUujXVeD70V6dnHu345YJ3ZQKt3e9+A9VJ5zbveXUT29lnnVO96Ca7P3ZQAC3ATVy8BdXT0LX/g3U++HOf3YBHpISJ9crmk00gR2QnXtw3wtt96qrrV+x3A7YDMxG+AtUAP4B8icoaI7CgiNSIyTkRuBs4AtgAXqGpQpW5ipLLQDTAmG6raCjSIyF7ej+aqakMGT3Ew8EyOzZA01kneYdhd18VqYBgwKJNGqOoGEZkGPIAL/7u6rNKGG1ny/1T1ta6PN/FlFbiJu/YdeEU5AoXO47K7Oyhmi3edVnWfTFUX4kaSvJRicQXug2FEps9ripsFuIktEekJJCrwTB6rqs+qquRySbeZyZtNc92Mj64TkSuARcBuwHnALrhK/iDcOPCJwAMi8u1Mn9sULwtwE2djgCrv9twCtiNIcrdOTTfrth/xuDmTDYjI5cCVuAr+EFW9WVXfVdX1qvqSNw78z97q14rIhEye3xQv6wM3cTbBu24A/pvJA715QboL1EBp9rmvTbo9pJt125evS7cN3reQy7y7d6vqYp9VfwScgyvazqJ4P/BMBizATZxN8K7ndz04Jg2R7MRU1ZUi0oDr197V94lEqoGh3t03M2jDGKC/d9t3B6WqrhCR1bjD9/fyW8/Ei3WhmDhr34E5t5CNSEP7DtZJAevshxsGCAFBnEIm3yLaP3BsGGGJsAA3cdZ+MM/8TB8Y4U5MgH9417uLyCd81jnFu24DMpmRMPnwd98DgERkOB1dNO9m8PymiFmAm1jypmdtH2P9USHbkobbgUbv9scmq/Kmcz3Pu/s3VU17CgBvHpX2A4TOEJHRPqtelXT78XSf3xQ3C3ATS16fd3vQnS8iY0SkzjtKsqjmr/YCuT24TxCRe0XkEyIyRESOx8381xu3M/b7XR8vItOT5nc5O8Um2p+7FnhORM4VkeEiMkBEJonIfbgdmOC6cx5OsY0xInJg+wU3btxb1PFz71Kd5Z/C5Jmd0MHElohcTceh9MluU9WzI25OoFxO6CAi0+nY4XqOqt6aYp3/h/tbBHXtLACOVdWPdaGIyLPAtIDHJttVVZenua4JkVXgJs5+BFyKm7Qq+SjHuQVpTQB1zgVOxnVhrAG24s6E8ztgQrZn4/Ge/wfAAcAfgcW4seQt3naewp3kYf9U4W3iyypwY4yJKavAjTEmpizAjTEmpizAjTEmpizAjTEmpmwulDzwzstojDGh8Dvyt2wqcBE5RURuFJHnReQj76CIO7t/pDHGFKdyqsB/gJv8qAFYQebnHeyWDck0xuSTO/7LX9lU4MDFwO5AX9xBDcYYE2tlU4GramLu5+4+1YwxJg7KqQI3xpiSUjYVeLZshIkxplhZBW6MMTFlAd6NPJ+ZxZjS8frr8PvfQ319oVtStqwLxcRSWxu88w4sXAirVkFzM2zbBrW1MHSou+y+O9T4nTHyxhvhpJNg+PAom13UVGH5cnjvPXj/fVi7FioqoKoK6urc33PPPd3fGIAHHoCrroLLLoMLL4Tvfx96FdW5NEpeWU4nmzRB/l2q+vk8PJ+CjQPPq+XLXRjssEPiR/X1cPfd8Le/wQsvQGOj/8MBKith/Hg46CA4/ng4/HD3M5Yvh129E8Tvuy/ccgvss09Yv0lRW7oU7r8fnnsOXn4Z1q8PXl/EhfgJJ8BZT5/N2Nm3dSwcNw7uugv23jvcRpeR9hFzvt/0VbXsLsB0QIE78/R8SmLOfpOzhx5S7dNH9aKLVFV1yxbVq65S7ddP1dWJ2V2239495ZJLfvPxhVOnqs6bV8jfOhzr1n3sR1u3qv7+96qTJuX29wTV4/iHLmKPjh/07Kl6220F+EVLU1K2pM4evwWlfLEAL2Ivv6zaq5f71+zVS+c/tVr33DP3oEm+VNCiZ3GrrmBo5wU9e6r+8Y+F/gvkR0uL6ne+o1pbq7pgQeJHt92mOmJEfv+ePWnS67lY25J/WCp/xwKzAO8I2ZOAW73LY94fZmnSz/43h+e2AM+HzZtVR49OhMBzTNW+PRvzGjbJl1oa9Dec3zl4QPWXvyz0XyI3Cxeq7rdfx+8zdqy+MatR9903nL9j++VCfqmtiLtTVaU6c2ah/xKxZwHeEbJXtv8xfC7Lc3huC/B8uOSSRBrM4xPam/pQA6f98j88pB/Rp/MPb7ml0H+N7Lz3nupOO3X6Xf7MF7S6R3Mkf8vLuabjzvDhqhs3FvovEmsW4BFcLMDzYOlS1cpKVdB6euseLIokcNov45ivK9mx4wciqn/5S6H/KplpbVU95JDE79AGejnXRPp3BNVHOKbjziWXFPqvEmvdBXhZjkLJNxuFkgdnnw23uRENF/IrbuLCbh9SXQ1jxrhREXV10KMHbNgAK1e6IcobN2bWhNG8xdMcxjBWuh/U1sKrr7oNxMH//R9861uAe9dfwv9xAxdn9BQ9esDYsTBiBGy/vbvf3OwG7rzxBqxe3f1zDGE1b7E7/dnkhv3Mnw977ZXxr2NsFEokF6wCz82SJaoVFaqgy9hFKwn+uj96tOrdd6s2Nvo/ZWur6qJFqtdfrxn1/Y5jvm6iruMH06ertrVF97fI1j33dPpF/h/fS/t3HjRI9YILVJ9+2u2G8NPWpjpnjurp4+Z3+5xXcEXHnTPOiOqvUHKSsiV19vgtsIsFeGQuvTTxZv8yvw8MhuOPDw4ZP7Oe36JH9XgirUA7hkc6dsaB6u235/93zqclS1R79060934+ndbvOXiw6i9+4YZpZmT6dL2TM7QH23yfux8bdAP93J3KStX160P4xUufBbgFeHFrbXU7u0A/ZDutYqtvKIwd8qEL79ZW1XffzWw799yjbaD3cqr2Z3234XYdHR8qetBBxV2Fn3BCoq3L2EX7srHb3++caf/VTZsy3E5LixsrX1WlCnot3wncxk+5rOPOXXeF8quXOgtwC/Di9uKLiTf5TXw1MBBm1B6h+sEHqj/8YXD/SVdtbaqnn554orcYpaN4K3BbVWzV1yonqv7oR5ltK2pPPJFodCuiU3ku8PcSWvU3nO8OlFq8OPPtbdqU6JNqRfQTzPPd1t7M7bhz2mn5/93LgAW4BXhxSxo6eChP+YbBJ3nc3RgwQPUf/8h8O/X1qldfrVpTowq6kh11NIsDw27S+EZtbc3/r5w327apjh2baPDNnNtteN/B5zp+8JOfZLfdrVtVx4xRBb2PUwK3uYSR7gCpU0/N7+9eJizALcCL2267qYKuZrBW0OIbBP/gOHdj331z685oa1M9+2xV0CWM1EGsCQygm2/O36+ad48/nmjoOgZ0+7v8jG93Du9c/o5//7u2V+FDWeG/zc/PV/3oo/z9zmXGAtwCvHh98EHinX4LX/QNgTo2aRM93Z0bbsh9u62tqp/+tCroPzk2MPS23z67naaRmTFDdf/99VKuC/w9TuTBjiNOf/7z3Lfb1OS6YUC/xo3+32Im5b6pctZdgNt84KZw5sxJ3HyOQ3xXO55/Uk2zu/PpT+e+3YoKuOkm6NuX4/gXXxn8V99VV62C3/0u902GZvJkVj38Mr/u6T/eewiruYUvIQCXXuouuaquhmOPhalT+fR5g31XmzULNm/OfXMmNQtwUzjvvuuOFAFmMdF3tU/xoLtx4IEwbFh+tr3DDu7Al1/9ip8u+hRDhviv+rOfdT91bSH9/PoKtjT7T+1/Hd9hMOvgmGPguuvyt+G774bnn+fgX3+WgQNTr9LWBnPn5m+TpjMLcFM4X/kK1NdT/8xs3hT/I/UmM9PdOOig/G7/3HPhwgsZMLgHV1/tv9rq1S6rilF9PfzhD/7L92cWZ3G7OyLyF79wE3rni/fhW1kJkyb5rzZrVv42aTqzADeFVVPDnIr98DtSeMfem9hp+u7Qr1+oJ104++yOczykcuONrle32Nx2W/AZzX4y8jYqUHfGnD32CK0dE/2/QDF7dmibLXsW4Kbggiq0/Q/rB8884yY5Of300NpQVQU/+IH/8vnz4fnnQ9t8VlRdV76fSZPgqDd/CX/6E/zoR6G2Zf/9/ZdZgIfHAtwUXNAbPBEMIt750MLzuc8R2Bf+xz+GuvmMzZwJixf7L7/4YpDKHnDOOdC/f6htCQrwxYvho49C3XzZsgA3BZc0GOVjgr6a51t1NZx3nv/yv/2tuEZU3HGH/7KhQ+Hkk6Nry447wk47+S+fNy+6tpQTC3BTUG1tbqpSP1Gfa/j88/338zU0wN//Hm17/GzdCvfd57/8vPNct1CUgl6rZcuia0c5sQA3BbVqlQujVGpr3ZzUURo2DA47zH/5XXdF15Ygjz3mdgv4OfPM6NrSbuRI/2VBH9ImexbgpqCCKrMRI/I76i1dQeH35JPBoz6i8uCD/ssmT4bddouuLe1GjPBfZhV4OCzATUEFVWZBgRCmk0+GmprUy5qbXfVbSC0t8M9/+i///Oeja0uyoGGYVoGHwwLcFFTQGzsoEMJUVwdHHum/vND94DNnwrp1qZeJwKc+FW172gV94FqAh8MC3BRUMVbgACee6L/skUdg27bo2tLVww/7L5s0yc0SUAhBr9d777lvDia/LMBNQXXXB14oxx3n3/++cWNhDw8P6sIJ+uAJW79+MGBA6mWtrbBiRbTtKQcW4KagirUC3247tzPQz1NPRdeWZB9+CAsW+C//n/+Jri2pWDdKtCzATcG0tcE77/gvL2SAAxx1lP+yJ59MuhPhJClBHxzDh8Ne/nOCRcICPFoW4KZgPvjAvy+5Tx8YNCja9nR1xBH+y16c0UrDZ7/k9rQ+9FBkber0wdHFEUcUZthlMgvwaFmAm4JZvdp/2fDhhQ+jiROhri51db2ttQfP/eV9l0ovvBBJe1S7D/BC23ln/2VBr7fJjgW4KZi1a/2XBU0qFboFC+Cyy6icNoVDG/wHXD/Pwe5GRAG+fHnwjsDDD4+kGYGCXre1s952Z8f4znesHM+TcKd3MyZAUIAP9j9LV/j++9/EmWsO40ke5oSUq81girvx2mvulD21teG0589/BhFmrPokkHrGqDFjop92oJPLL4f//IfB7+4F/CnlKmtnL4fZl7s7RxxR+J0cJcAC3BRM0QZ40vCTqfhX17OYyFZ6Ut3SDK+8AtOnh9Oeq6+GpUt5gd8C56dc5eCDw9l02t58E156icHt5y5NYS1JL2rQi2/SZl0opmCKNsCHDIE99wRgPPPoTUPK1Zqo4TX2dXfC6kZZvx6WLgWSKv4Uprx0PVx1FTz6aGGOMvJesMH4v6idAtzvUFKTEQtwE63334dx42DaNNbe8ajvaoNbV7mEb22NsHFJpk4FoJJWJvGy72qJUA0rwL0jhjbQnzf4hO9qU+b9Gq68snDH0XtDhroL8MQuYavA88IC3ERr9Wq3k/C551i7zP80LYN/dqmrhMeMibBxSaZ0VLtB3Sgz8bpbZs4M58PGC/CX8T9r8I68z654h7Tus0/0E4FDogKvpZFebEm5yjZ6Uk+du2MVeF5YgJtoJb1xO32l7iJRyQ0cGHaLUvMqcIApzPBdbTbeucTq610/cL55AT4L/1MTTWYmiRGXUZ7CKJkX4EKa3ShWgeeFBbiJVqYBXqijeUaOTAzrmIj/xCfvsTOr2M7dmTs3/+3wzkWW+KBIoVMXzwEH5L8N6Uh6ndIKcKvA88IC3EQrLgEukuhGGcBGRrHEd9VEuOY7wDdtSsw1EFSBd/qAKXAFDlaBR8kC3ETLC3ClyAMcYN99Ezf3Z7bvaokAz/eZe994A4D32ZEPGJpyFaGNfXnN3amthdGj89uGdFkFXhAW4CZa3hu3gT40U51ylZ5spU/70L1CBviECYmbQd0os8Z/CebMgX/8I7/bnz/fPX9A9b0Hi+mLd463ceOgokBvaavAC8IC3ETLC/Duqu/ETrliCPDhw5k4uafvarM/HO7WrU79gZS11193zx/Q/93pg2XvvfO7/Uz075+YvCatAN+yxR29anJiR2KaaHmVV1rdJ1DYAB861LV30CD2aYCKfm4K3K5WrXKXvB/K7lXgc5ngu0qnrp1CBniPHm7E0Lp1wQE+ZhqceqV7XQs9W1kJsAA30UqzAu+4U8BDMkUSHyB9+rju5cWLU6/6+ushBPg558CYMcy7bSJ+R6gn+r8BPuF/oE8kHn4Yevdm8Ixh8LXUq6zdYwpc4X9EqcmMdaGYaGUa4IWeFDxJUD56xXJ+nXsu6376B95r9j/J5d683nGn0AE+eTKMH8/gPfxfszVrImxPGbAAN9HatAmADficPBEYyPqkOwU6kCeFoB6KUAKc4IEtu+0GfTd/4CbSuuOOovmwC3rJNm6MrBllwbpQTLTuuQc2baL+7l3hb6lX6TtiEAydDA0NbudYkSi2AB8/Hjd0cOLEwo3/TqFvX/9l9fXRtaMcWICbaHmnjakPOKt73bmnwg9OjahB6QsK8IULoaUFKvP8jgo6NihplGNRqavzX2YBnl/WhWIKIuiNHBQAhbTLLv5t27oVlvgfrJm1bivwImQBHh0LcFMQcQzwiopod2S2tgbPj1WsAd6rlxtVmMq2be7DzuSHBbgpiDgGOETbD/722/5h16eP+0ZQjESsCo+KBbgpiLgGeJQV+IIF/svGjCnu42AswKNhAW4KIq4BHmUFvnCh/7JCneciXRbg0bAANwUR1wAPqsDffTe/45yDKvCxY/O3nTBYgEfDAtwURFwDvF+/4L5nbwbYvLAK3HTHAtwURFwDHIK7UfI1JXh3I1CsAjdgAW4KQLV0Azyo2yMTy5ZBU1PqZb17w/Dh+dlOWCzAo2EBbiK3ZUvqaVnBnVA939Nq51tQ9ZuvAO9uBEqhztuQLgvwaBT5v4EpRXGuviE4wIP6rTMR5/5vsACPis2FYiIX9wDfYw9XAaf6FrF2Lax++g22WzkHhg2DQw/NahtxHoECFuBRsQrcRC7uAV5dDaNGqe/yBYdfCGedBbfckvU2uutCKXYW4NGwADeRi22Av/UWfPWrMHUqY9/+p+9qC/ES9vXXfdcJEvcRKGABHhULcBO52AZ4YyP89rcwYwZjW+b6rrYAL2EXLYJmn3OhpVJfD83N3Y5A2Xnn9J8ycqtWwaJF1H3oPzVj/Yz57nRxp5wSzhSOZcQC3EQutgG+116JafbG4L+XMVGBt7T4n0Qzleuvhz59WHjENwKbUNQjUE4+GcaMoe67PifFBOqXrYFbb4UHHoCVK6NrWwkq5n8FU6JiG+DV1W4PJjAW/07qRAUOmU2QMn8+bNvGgnd6+64ytuFl+MMf4KWX3DeCYuO9gHX4v8j1JL3I1p+SEwtwE7nYBjgkJkPZnbeooDXlKmsZwmqGuDuZ9IPPmQMkVfApjHnzAfjKV+Cgg+CRR9J/7qhYgEfKAtxEZ/vtYYcdqL/6l76r1L32H7juOtfXvG1bhI1Lk3cYZi+2Mor/+q6WCOF0K/D162H5cqBLBd9Fp8o/6JDQQrEAj5QFuIlGayusXg2rVlG/3j+Y62Y8Cpdd5kZ7FOOE10nTEabVjZJuBf7aawC0UsEi9vJdLdH3XlMDo0al99xRsgCPlAW4icbmzYmbnd7AXSTe+DU1+T9DcD4kBXhaOzJXrIANG7p/Xi/AlzOCJmpSrlLLZnbhHXdnwgT/85YVUhoB3kAfEqPoLcBzYgFuopH0Rm2gj+9qiTd+sXaGJ53ZOO0dmelU4a++CgT3f+/FIirao2/ffbt/zkLw/jZVtFBN6rGQbfSgkVp3xwI8JxbgJhpJb9TN+I+y6EODd8M/5AtKJFGFB1XgnQI8nUnCvQBPu/97v/26f85CSPrgTbyWKSQ+xItxJE2MWICbaCS9URPVVwq98bpaijXAIbHzcA8WB45EWXPdn90x8eefH/x8GzfC0qVAcIB3+sAo1gCv6ej+qcU/nLe0dxNZgOfEAtxEI80Ar2GLu1Hrv07BeRV4dyNRFkw8O725X73hg5BmBV5d7Y7oKUZJAZ54LVNI/A9s8V/HdM8C3EQj6Y26xWcnHSRVbcUc4NOmwde/Dvfdx5ij/c+vlvbc4F73SXcjUBIBPn68mzi9GCW9blaBh68Id/ObklRKFfjYsXDjje7mPHjosdSrpT03+E47wWGH8fasjTTVp/5w601DxwiUYu0+AdhuOzjgAKitpWZuNWxMvVrjBZfCuA2w226RNq/UWICbaCQFeFoVeI3/OsUkaGrXtCvw00+H009nwYMKJ/tsh4XFPwIF4MAD4eWXAag9Angq9WpbTjodjoyuWaXKAtxEI6kLJfYVeJJ8np3njQX+By6NO3Q7OOh7rrtl0qTMnrhAgl5C6znJDwtwE40SrcCDzs6zZo27DBmS3nMFnoXnuBHwrauzamOhBL2Etu8yPyzATTTOOQdOOAFt3ELjuD7gc1Ljmmt+BM2bi7ufN0mvXjBypP+01gsWwPTp6T1X0HDxceMyblrBWQUePgtwE43evaF3b7Y1+5+RvrISqr57abTtyoOxY/0DfOHC9AJ827bgqcPjcBaerqwCD58NIzSRCqq8YtLt/TH52JG5ZIn/5Iv9+rmBKnFjFXj4LMBNpILeuDHp9v6YfOzI7O4s9MU4MWN3gl5PC/D8sAA3kQr66hzXCjwowNOtwEut/xuCX0/rQskPC3ATqVKswNtHoqTSPhKlO91V4HFkXSjhswA3kSrFCrx9JIqfdLpRSrECt52Y4bMAN5EqxQocctuR2dQE//WfE8sqcOPLAtxEqhQrcAgO2e7O57BokTvjXCqDB7vpReLIKvDwWYCbSJVqBR7UzZE0W2zGy8eNi+cIFLAKPAoW4CZSpVqB77OP/7J586ClxbujCg8/DG++mVjunQ4z4+ctdlaBh88C3ESqVCvw0aP9P4CamryjLBctgqOPhhNPhIsucmFOcIAX88SD3bEKPHxZH0ovIpXAROAQYCwwGGiftmeNd1kAPA/MUtWWVM9jykspHokJ7gTxEybAzJmpl7/2rbsY+9TZHaX4E0/AHXfQ+rmzmDfP/3ktwE2QjANcRA4HvgT8D9AreVGXVTXpdpOIPAz8UVWfzLiVpmQEfXWOcwUOLmx9A/zx1ZyJF97PPANTp8KDD/LWG800NvZM+ZiaGjfGPK6sCyV8aQW4iFQA5wKXAyPoHNbrgWXABu82wEBgALCrd7sGOA04VUSWA9fiwtxnWiNTqkq1Aofgavk1vIVnnQWDBrmZuz7zGV69zWf4Ce7MaT165LmREbIKPHzdBriInAxcDeyOC+6PgIeAx4FXVHVpN48fietqORJ3vpFdgd8BF4vI91X1wVx+ARMvpboTE4J3OM5mf7ZRSdXtt8Ptt8Nhh8E3v8lLrxzv+5g4d5+AVeBRSKcC/6t3/SxwE/CIqm5NdwNewC8F7hWR84Hjga8D073njnGNYTJVqjsxAcb2X0kNA9iS4oxDjfRmPnuzH94ey6efhqef5sWerwOpxyDuv3+IjQ3Tyy/DzJnUftQEfDflKo0NrTD5YPcPcf757mIyls4olH8DB6vqYar6t0zCuytVbfae4zDgYO+5TRkp5Qq8asROTBy8zHf5ixzU6X4DvZnXvKfv+lOm5K1p0Xr8cbjkEqqu/B4VpO4iatUebHtxlhtjuWJFxA0sHd0GuKoepaoz8r1hVZ2hqkfn+3lNcSvlChxg8mf8J+6eyeRO92cxkVafL8GD+jYzepSmXFb0vBdSSDpFXgqJc6Nah3jWshoHLiIfiMjjIlKV7waZErR1K6xcCRs2sGWz/067uFfgAJOP6e+7rGuAd63Ikx1U/Vpsj8BMfiGDAjxxblTrEM9atgfybA8cAViAm+7NmQPDhsHAgTQ+8ozvajXfuxiOPBIujd9p1dod5J/JvMMIlrNL4v5/mOa77uQv7B7fY+iTvkrV4B/OVoHnLpIjMUWkWkT+JCIXRrE9U2SSKqzGFDv42tUunAX//jfMmhVFq0IxeDDsvrv/8sc5CoBGagID/KDjBua7adFJCvC0ulCsAs9aWgEuIrmOFKkEzgZ+kePzmDhKqrASX5tTSFRrMe9LOeww/2XtAf4ch7C103FwHWpq4MADw2hZRJJev6AK3LpQcpduBd4gIrNE5A8i8tWkn6e7l0W6XJtykhTggRV4e7UW872ZRwfsmn+SI9hGJY/hv9Khh7qTRMRWphW4daFkLd1D6auB/YCuhxYsEZG5wBxgLjDX58Ce4d51UxZtNHGXVGGVSwVeWZk0A2GSevryn5Nu4J9PnQL1qR8f9AEQC1aBRybdAD8NF+DtIT7A+/lQ73JM+4oi0gDMxwX6fNyRm+2j9Jfk3GITP5lW4DEP8Lo6N9XJs8+mXn7evK+xzCe8oQQC3CrwyKQV4Kp6P3B/+30RaZ/D5HvAXsB477oKqAOmQJcxU6675bYc22viKNM+8Jh3oQAcc4x/gC/zP9aHkSNh1KhQmhSdNEehWAWeu6ynk/X8SlUbAbwx4WOACd5lPO4Y4cHAKuCPwA05bs/EUZPrOVOgyWfHHZRWgJ9xBlx+eWLK77SdeWZ8Rw8mpBngif8FC/CsZRvg/XHhnPjLq+o2YJ53sUrbdPDeoNuoos1n6psetFDZfth1CQT4sGFw1FHw2GPpP0YEzj47tCZFZ+BA+OY3oaaGXk/uDT6jQrdc9F044yuuz8lkJasAV9WPAJ+Zj43pwqvA06q+IeZDMDp88YuZBfjhh8Muu3S/XtHr1w9+4UYM12zFN8Cbho2CA6JrVimyU6qZ8HkVeFD/d6/kAUolEuAnnphZIH/zm6E1pWCCXkrrOcmdBbgJX3U1DBxIU3V/31U6VeAl0IUC0LMn3HhjeuuecAIce2y47SmEoABvskHFObMAN+G7/npYt44tcxf7rtJr5+1gxgx46qmSSrITToDTTw9ep39/uOmmEth5mULQZ7EFeO5yHYViTNqC3rA1/XvB5K4jT0vDrbdCayvcd9/Hl+2wg5s+e+edI29WJKwLJVxWgZvIBL1hS6TbO6WePeHee+HBB91ki3V1sPfe8IMfwMKF7napsgo8XFaBm8gEvWFLOcDBdY+cdJK7qJZmd0kqVoGHyypwE5nALpTS2G+ZlnIJb7AKPGxRzQf+J+9yXh6mps2lHcO8drwvIltFZLmI3CAiA7p/tMlVuXahlDOrwMMVVQV+NvAF4LfAIhE5I6LtJojISOBV4BzgFdzc5G8DFwEvisigqNtUbqwCLz9WgYcryi4U8S6jgDtEZF6E2wb4DbAd8A1VPUlVL1fVw3BBvgdwdcTtKTtWgZcfGwcerkgCXFUrVLUCNy/4F4F7cWEaCRHZDTgSWA78usviK4DNwJki0juqNpUjq8DLj3WhhCvSnZiqulJVb1XVz6nqjhFuuv0kV0+oalvyAlWtB2YAtUCcT2RV9KwCLz/WhRKuchmFsod3/ZbP8vYTTXzsdLQiot1dQmlxCbIKvPxYBR6urAJcRPbLd0NC1s+73uSzvP3n/cNvSvmyCrz8WAUermwr8GdEJO4nfkrWPjL3Y9W0qkp3l4jbGltWgZcfq8DDlW2A9wEeFpFz8tmYELVX2P18lvftsp4JgVXg5ccq8HBlG+B/xR2Gf4uI/DCdB4jIMSLyapbby1X7NHgf6+P2jPau/frITR5YBV5+qqr8jzxtaXEXk72sAlxVT8WNnxbgShH5g4ikfC4RmSoizwH/xJ0rsxCe8a6P7NpOEWk/CfMW4KWoG1ZOrAIvPyJpjAVvaYGtWyNrUynJehSKqn4L+Aau3/hc4CERSdRRIrKPiPwL+A8uIAVYlFtzs27rUuAJYATwtS6LrwJ6A7er6uaIm1ZWynkyq7Lz7LPwmc/A8cdTs+0j39Wa+u/gyvQLLoiubSUkp9kIVfUmEXkPuBs4Drdz81u4w9NPpuPoy7eAHwP35NbcnHwVdx7PX4nI4bgPk0nAobj2fb+AbSsLQRW4daGUmBUr4K9/BaAX9XTsZupsS2uVd8P2aGYj53Hgqvp3XAiuBSYCzwGf9p57KW4OlDGqereqFmzMtFeF7w/cigvubwEjgV8BB6nqukK1rVxYBV5Gkj6RO50ur4vEia4twLOS83zgIjIYOAXXDQGu4lbgB8DPVLU1123ki6q+h5vMykRl1SqYNQt69aJpzSSgLuVqNb2UjtGcJvaSArzTCau7SJzo2gI8K1lX4CIySESuBZbhqtlaYAOwGvdOPA//UR+mXLz0kjsx5Cc/yZaFb/uu1mvKvu5N/9nPRtg4ExqrwCOR7ZGY1+CC+9u4ynsz8BNgV9x8IouBnYEZIjItP001sZTUb5J4s6ZQwxa3bmvRfGEzuci0ArdB4VnJtgK/HHcwTzNwA7Cbql6hqvWquhyYjNth2B94TESsrCpXSZVV4s2aQuJNbnszS4NV4JHINsBbgZuBUap6iaquTV6oqhuAw4EHgWrgThH5Tk4tNfGUSQUOtjezVFgfeCSyDfC9VPUrqrrSbwVV3YrbuXmTt52fikjXubhNqbMKvDylGeBWgecm2yMx/5vmeqqq38B1uQCcn832TIxZBV6erAslElGdkec64PPAtii2Z4qI98ZsoQctVKVcRWijqv1fwyrw0pD0QWxdKOHJeRx4ulT1HhH5IKrtmSLhVeDdVd+JEeBWgZeGTCpwEaioAFX/ma9MSlGfUu3ZKLdnioBXWaXV/w1WgZeKHj3g3nvhoYfodeqJvqttuernbujo5s0W3lnoNsBF5FUR8X8FsiQinyrg9LImKmlW4AlWgZeO006DE0+kZsyuvqs0tVRacOcgnQp8H+BvIjJXRL4sIgOy3ZiIDBSR80VkPm5O8QnZPpeJCavAy56dlSc86fSBTwOuw00A9TvgRhF5AngcmA3M9YYMfoyI9MJ9AEwEjgKO8LYpuLm3bWx4qRs/Htato2ntUPffkkKnALcKvOR0Ox+4yVq3Aa6qzwMHicinge/hAvl43PSxAC3ezskN3gVgIDAA2BHo4f2s/XvSq8A1qvpgXn4DU9y+/W349rfZ8jJukoUUavYfBy9uc+/mnj0jbZ4JX9CXKqvAc5P2KBRVfQB4QEQm4Caq+hSwPVCFm/dk54CHrwYeAG5W1bnZNtbEV7dzgVdWQp8+kbXHRMcCPDwZDyP0AvirwFdFZDRwMDAGGAIM9lZbC6wBFgLPq+qSvLTWxJadzKF8WYCHJ9cz8iwBLJxNtxob/ZfV1kbXDhO9oNc36P/CdC/SceCmfFkFXr6sAg9PtvOBH5B8AmNjumMBXr4swMOTbRfKS0CriCwF5iVfVHVFvhpnSod1oZQv60IJTy594D1wp0wbjZs2FgAR2UiXUAcWqGpzDtsyMWcVePmyCjw82Qb4brijKPdJuuzkLRsATMcdANSuVUQW4yr0z2e5TRNjFuDlywI8PFkFuHfatOXAQ+0/885O3x7m03Fn5GmfP7QSGIsbbmgBXoasC6V8WRdKePI2CkVV16rqv1X1OlU9FneQzw2AAnOBa4B/5mt7Jl6sAi9fVoGHJ7RhhKq6UVUvAU4HxgONqpr3WQ1NPFiAl6+guVCam91ssiY7oY8DV9X7gFuBK0RkXNjbM8XJulDKl4hV4WGJ6kCeW3H94RdGtD1TZKwCL28W4OGIKsCXe9dHRLQ9U2QswMtb0GtsOzKzl9UoFBG5C5iD2zk5V1XXdvOQ4d710Gy2Z+LPulDKW9BrvGX2Alix0c1GOX58ZG0qBdmOAz8d+Gz7HRF5n45An4ML9WXesr7Aj71VN2DKklXgZej55+Fzn4MtW6hZ/zTwiZSrbTnl88BcOPxwePLJKFsYe9kG+D9wI0va5wDfybu0n+QBEWnEzQM+FOiJG074cNYtNbFmAV6G2trgvfcAqGGz72qNeOW5dYZnLNsDeU4EEJH+dBy8M8G73sN73t5A8tlMXwMuz76pJs6sC6UMJX0y1+L/D5A4X6oFeMZynQ98I/CMdwFARKqBcbgjL4d5P54HPKqqbblsz8TMiy/Cww9DbS1b1l6C+0z/uJol82FrJQwZ4i6mNCQFeA3+4WwBnr2cAjwV7wTHr3oXU85eeQWuvRaALXzDd7XaYw4BNsHXvgY33RRR40zo0qzArQsle3ZCBxOepDdk4k2aQqI6s87w0pJpBW6nqM+YBbgJjxfgLfSgJTGvWWdCGz3xZhq2AC8t1oUSOgtwEx7vDZl4g6ZQSyOSuGN7M0uKdaGEzgLchMcbehIU4J0qM6vAS0vSLFZpVeDbttnMVhmyADfh8SqqtPq/wQK81IhAdTUQHOCd/j+sCs+IBbgJT5pdKAkW4KXHe03TGgcOFuAZyvswQmMS0gjwTpWZ9YGXnpoa2LgxuAtl0DAYfWDwxOEmJQtwEx6vD9y6UMrYyy9DVRU1D/SFr6depfHYz8Dtn4m2XSXCAtyEx7pQzHA3EWntYP9VrNcke9YHbsKTaReKBXjJshM6hMMqcBOer38d3nuPxtmj4O+pV6kZVAvDJ7juln79Im2eiY6d0CEcFuAmPF/4AgBb/oxvgNcefzjcOie6NpmCCDyhg1XgWbMuFBM6mwvcWBdKOCzATeiCviJbgJcH60IJhwW4CZ2dzMEEvc6b/U/WY7phAW5CV1/vv6xPn+jaYQon6HVuaIiuHaXGAtyELugNWlcXXTtM4QS9zg0NoBpdW0qJBbgJXVAFbgFeHnr2dJdU2tpsR2a2LMBN6IIqcOtCKR/WjZJ/FuAmdFaBGwh+rYP+R4w/C3ATOtuJaSD4tbYAz44FuAmd7cQ00P2OTJM5C3ATOqvADVgXShgswE3orAI3YDsxw2ABbkKlahW4cawCzz8LcBOqpib/E41XVSXOeWvKgO3EzD+bTtaEysaAlzlVaG6Ghgbq2iqB1HO+Nzz6HKx70k2M8r//685ob7plAW5CZWPADb17Q2srdXwPuDrlKvWPz4THf+LuXHONfTVLk3WhmFDZDswyJ5L4qtUH/3+GBpK+jtkezbRZgJtQ2Q5M0/5C1+H/z1BP0qe5dYinzbpQTDhOPx3efJOGlsOA61OuUrfpPbjjWVeKT5sGAwZE2UITFe+rllXg+WcBbsKxaBHMm0c9I31X6fPmbDjrLHdn1izYf/+IGmcilWkFbgGeNutCMeHwvgZ3emN20ekNbR3ipSuNPnDrQsmOBbgJh/cm7PTVuItOb2jrEC9d3odzUAVuXSjZsQA34fDehFaBG+tCCY8FuMm/lpbEKVasAjcZDyO0LpS0WYCb/EuqoNKqwHv3hgr7VyxZaXShWAWeHXvXmPzLNMCt+i5t3utbwxYqSD0xTjPVNFPl7liAp82GEZr8S/oKnFYXivV/l7Z+/aBvX6RPH/p82MhHbalf74ZLr2LgkB4wZUrEDYwvC3CTf0kBnlYFbgFe2i65xF2AumHw0crUq9V//bsM3CXCdpUA60Ix+bdxY8dN+vuuZl0o5advX/9lSf82Jk0W4Cb/NmxI3FzLYN/VBrPW3bBD6MvGoEH+y9auja4dpcIC3OTfaae5YYQrVrCuboTvaoMO3wcmTYKxY6NrmymooABfty66dpQK6wM34ejVi23b7cSmgCG9Ax+72/4Dy4wFeH5ZBW5Cs369/7L+/aHSwrvsDPbvUbMulCxYgJvQBFVUQZWYKV1WgeeXBbgJTdAbMqgSM6XLAjy/LMBNaIK+ElsFXp6sCyW/LMBNaKwCN11ZBZ5fFuAmNNYHbrqyAM8vC3ATGutCMV1ZF0p+WYCb0FgXiukq6KDbjz6Cbduia0spsAA3obEK3HRVWemOAfBj3SiZsQA3obEK3KQS9NpbgGfGAtyExnZimlRsR2b+WICb0FgXiknFZiTMHwtwE4rW1k6zyn6MBXj5CupCWbMmunaUAgtwE4qVK6GtLfWyfv2gujra9pjisf32/svee6cNVqyAGTOguTm6RsWUBbgJxfLl/st23TWyZphi09LCiL7+Hd3Lr70Xhg+HqVOD/4kMYAFuQhL03tvFzntYno4+Gnr1YpcfnuW7ynLduePOO+9E0Kh4swA3oQgK8BEjomqFKSpVVdDaygiW+67yDkmf7laBd8um1Df5s2ED/PSnMGIEy184ARiecjUL8DLlvfC74F9Zr2QnmqmiJ9sswNNgAW7y57//hZ//HIDl7IlvgC/8FzyiMGoU7LFHhA00BeX1nfVhM4NZw1qGfGwVpYL3GM5I3rYulDRYF4rJn6SKaTkjfFcbcfP34Pjj4dxzw2+TKR5JX72CulES/ztWgXfLAtzkj1cxtXpVlJ/Em9f6UspL0t7rtALcKvBuWYCb/PEqpvcZSgtVKVfpx0b6s8ndsQAvL5lW4CtX2ljwbliAm/xZsgSApYz0XaXTG9cCvLwMHgy1tUBwgCf+f1Rh8eIIGhZfFuAmP1paYOZMAF5lP9/VLMDLmEiiG2VXlvmu9hr7dtx54YWwWxVrFuAmP+bMgYYGAGYx0Xe1fZjTcWekf6VuStSeewIwgbm+qyxmTzbSz915+eUIGhVfFuAmP559NnHzFQ7wXe0AXnE3ttvOKvByNHkyAEP5gJ1Y4bvaq1/9E7z2Gvzxj1G1LJYswE1+PPMMAGsZxDJ2811tIrPcjWnT3FdqU14OPjhxM/G/kMIrw06GffaBHj2iaFVsWYCb3G3bBm++CcBs9vddbVfeZjDeREbTp0fQMFN09t0XLroI7ruPA757uO9qs/yz3SSxIzFN7qqq4K234PHHeebirbAk9WqdKi4L8PJUVQU33ADAxAHAT1Ov9vzzbr94pSVUIKvATX5UVqLHHsdfmk/2XSUR4EOGwF57RdQwU6z29/+yxtq18PTT0bUlrizATd689FLwwXOf5N/uxpFHWv+3oX9/mOg/YIl77omsKbFlAW7yJmjAwJ6jW9n7xvNg/Hg4y38+aFNePvtZ/2UPPBB8Wj4DoqqFbkPsiYgClPPfcsEC2Htv/9OoXXUV/OhHuKPrwCpwA7ij5YcP7/i36OqSS+D666NtUzER732iqinfMBbgeZB1gDc2ugMVZs925wFsa4OKCpeEU6ZAnz7uflsbDBuW/4avXQvLlrkyZ8IENzY7Cw0NcMgh7lgeP4sXw+67Z9dMU9qmTYPnnku9rLIS/vUv+OQno22Tr3Xr4Jpr4IMP3F7WjRvdCV5bWqBvX3eg0pgxbqrklhY3l8uQIe6Yh169Mt5c2Qe4iFQBXwUmAPsAY4Aq4MuqekuetpFZgKu6ubNPOgkWLux+/YED3T9OvixZ4p+mZ5wBvXu708Z/+cvuBJYB1fJLL8FXvgLz5/tv7vDD4cknc2yzKVn33Qennea/vLoarr0WLrggxcmwFyyAW25xw1jXr4e5c11o7ryz62QfPhz22w+uuMIVQ7nautU9b1NTZo/r2RP+/W9X6WTAAlykP9Dek7YKaMadaaBwAd7ujDPS31Pz0UdQV5dp0z7uww/hL3+Bb34zeL2pU91YriT19W7CwUWL4MUX3bE78+Z1v8nZs917yJhU2trgwAO7H/s9cCAcdZQ7mHOffVxtscMOUCHq5uE55RT3/53qgatW5W9M4vTp8J//ZPYYEfeNd+DADB8WHODlMMqyETgWmKuqH4jIlcAVhWjICy+4wlvVu8wej1KLIolLGxWd7icuVzegO9R1PDbLS1vbDmjrhWhlE9rSwjaq2Er1xy8vVNM4pYkNjb1Yv94VN95UJxk56ywLbxOsosL1c3dXnK5f7+qd5JqnqgoGDhQGVn2CgR/eTx319KKJXjRRzVZ3e30TPc/6kB67DKOiwh3cWVHRcUm+33VZu/YvoSJA7bcQ3DBYQdO73mkYPDiw8/Pg3h+5HGxa8hV4V0kBHnkFftZZcMcd+dhiPOy6q6uqBg0qdEtMHFx6afntsGxudh9CfrqrwG0YYYTKaeDFwIHw6KMW3iZ9P/sZnOx/HJhJwQK8GyKi3V3Sf64wW1o8Ro92XYR2vmKTiR49XPfIl75U6JZEJ9dMsACPUKkHeGWlGykwezaMG1fo1pg46tkTbr4Z7r3XDSAxwWIR4CKyPJ1KOOlyZ762rarS3SX93yNfrSouO+wAF1/sRnL95jduOKwxuTjtNDc/2h/+AAcdVOjWFK+4jEJZCmQy8PL9sBqSi7gHuIg7nmjXXV03yYEHuiFde+6ZnyG2xiTr1csdivDlL7sReC++CDOfb+X1W2ezbE0fljOCRnoXupk5yTUTYhHgquo/cXCMTJ7sDs4SAZk/D5nzaqoBg1TQlvLncsEFSM8q9/hsLwsXUPHXvySes5KWxHCrroMJe9FEfzYy4LxTGfjTb9Ovn82vbwpj8GA44bg2TrjvbFjjvmAr0Egt6xnIBgawnoE0UusNInSXrVQnrtuooO20M2gbM462NmhtdWPQu95uv98+qMz3+v77Yd06FG+kiN/16WdATe3HHg95KOpUtawuwJXea/+lPD6nuj9lBi64IPNh3AsWZLaNVC67LPPt7rKLaltb7ts2JhdLlqgOGpTboRBnnpm/9lx4Yffb22OPnDaRlC0psycWFXhJer+bXp7evd1eQRHXP7HDDrB5c+7bXbky88e88447Vn78+Ny3b0y2Ro1yO1ouuwxuu82VyZn697875hzKhiosXQozZrgzUR11lDus/v333V7XQYPc/ELt79UjjshuO2kqiwN5RORyYE/v7gRgPDCTjnPHvKA5HNST1aH027bBmjXu9nbbRXvqkXffdYfJP/kk3Hmn69cZMsT9cw4b5t4ou+3mfrb99u4QuV12ia59xnRn61YX5u+803HY5Nat7n59vbs/dKj7WVMT1NS4/+v99nNzmcRE2c+FAiAizwLTAla5TVXPzuH5y346WWNM/lmAR8AC3BgTBjuU3hhjSpQFuDHGxJQFuDHGxJQNI8wjifuhlsaYWLEK3BhjYspGoRRI0sgVK9vLjL325Svfr71V4MYYE1MW4MYYE1MW4MYYE1MW4MYYE1MW4MYYE1MW4MYYE1MW4MYYE1MW4MYYE1N2II8xxsSUVeDGGBNTFuDGGBNTFuDGGBNTFuDGGBNTFuDGGBNTFuBFQESqROQiEfmziMwVkWYRURH5UqHbZvJHRIaJyJ9E5H0R2Soiy0XkBhEZUOi2mXCIyCkicqOIPC8iH3nv6zvz9fx2Rp7i0Bu4wbu9CvgQGF6w1pi8E5GRwExgO+DvwJvAAcBFwNEiMkVV1xWwiSYcPwDGAw3ACmDPfD65VeDFoRE4FhiqqjsAfypwe0z+/QYX3t9Q1ZNU9XJVPQz4BbAHcHVBW2fCcjGwO9AXuCDfT24BXgRUtVlVH1XVDwrdFpN/IrIbcCSwHPh1l8VXAJuBM0Wkd8RNMyFT1WdUdYmGdMSkBbgx4TvMu35CVduSF6hqPTADqAUOjLphJt4swI0J3x7e9Vs+y5d417tH0BZTQizAjQlfP+96k8/y9p/3D78pppRYgOeJNyRMM7jkbSiRib32M5TbzHImIzaMMH+WAk0ZrP9+WA0xRae9wu7ns7xvl/WMSYsFeJ6o6uGFboMpWou9a78+7tHetV8fuTEpWReKMeF7xrs+UkQ6vedEpA6YAmwBXoq6YSbeLMCNCZmqLgWeAEYAX+uy+Crckbi3q+rmiJtmYs7OyFMkRORyOg6znYA7/HYmHUPMXlDVWwrQNJMHKQ6lXwRMAg7FdZ1MtkPpS4+InASc5N3dATgKeBt43vvZWlW9NOvntwAvDiLyLDAtYJXbVPXsaFpjwiAiw4EfA0cDg4APgIeAq1R1fQGbZkIiIlfijrb1846qjsj6+S3AjTEmnqwP3BhjYsoC3BhjYsoC3BhjYsoC3BhjYsoC3BhjYsoC3BhjYsoC3BhjYsoC3BhjYsoC3BhjYsoC3BhjYsoC3BhjYsoC3BhjYsoC3JgQichoEdnmnQf1Wp91RETu89ZpEJGJUbfTxJMFuDEhUtUlwK3e3a+LyJAUq/0v8BmgFThNVWdF1DwTcxbgxoTvKmAr7sw7305eICJfBy7x7p6vqo9E3DYTYxbgxoRMVVcAv/Xufk1EtgMQkROBX3o/v8rOuGQyZSd0MCYCXtfJ20Af4HrgftzJjmuAP6nquQVsnokpC3BjIiIiPwZ+CDQCm4EhwL+AE1W1pZBtM/FkAW5MRESkL7AMGOj9aDYw3c5Gb7JlfeDGRGcgkFxpX2LhbXJhAW5MBERkIPAosF3Sjy8qUHNMibAANyZkItILeBjYE3gP1w8OcLKI7FewhpnYsz5wY0IkIhW4EScnA5uAqcCbwCJgFPC4qh5duBaaOLMK3Jhw3YAL72bgZFV9wxtx8hNv+VEickihGmfizSpwY0IiIt8BfgYocKaq3pW0rAewENgdmKGqUwvTShNnVoEbEwIROR1on7zq+8nhDaCqrcCPvbtTROTYKNtnSoNV4MbkmYgcCjwG9AR+r6rn+6xXAbwB7AXMBfZVe0OaDFiAG2NMTFkXijHGxJQFuDHGxJQFuDHGxJQFuDHGxJQFuDHGxJQFuDHGxJQFuDHGxJQFuDHGxJQFuDHGxJQFuDHGxJQFuDHGxNT/BxBDvxhZMULZAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "\n",
    "# Create the figure and axis objects with reduced width\n",
    "fig, ax = plt.subplots(figsize=(5, 5))  # You can adjust the width (7 inches) and height (5 inches) as needed\n",
    "\n",
    "# Make sure the font is Times Roman\n",
    "plt.rcParams['font.family'] = 'Times New Roman'\n",
    "\n",
    "# Perform the prediction\n",
    "with torch.no_grad():\n",
    "    prediction = lem(test_tensor)\n",
    "\n",
    "final_time_output = prediction_tensor[-20, :]\n",
    "final_out = final_time_output.detach().numpy().reshape(-1, 1)\n",
    "final_true = u[-20, :].reshape(-1, 1)\n",
    "\n",
    "# Plot the data with red and blue lines, one with dotted and one with solid style\n",
    "ax.plot(x, final_out, color='red', linestyle='dotted', linewidth=12, label='Prediction')\n",
    "ax.plot(x, final_true, color='blue', linestyle='solid', linewidth=7, label='True')\n",
    "\n",
    "# Set the axis labels with bold font weight\n",
    "ax.set_xlabel(r\"${x}$\", fontsize=26, color='black', fontdict={'weight': 'bold'})\n",
    "ax.set_ylabel(r\"${u(x, t)}$\", fontsize=26, color='black', fontdict={'weight': 'bold'})\n",
    "\n",
    "# Set the title with bold font weight\n",
    "ax.set_title(r\"${t = 0.81}$\", fontsize=26, color='black', fontweight='bold')\n",
    "\n",
    "# Set the number of ticks for x-axis and y-axis to 3\n",
    "ax.set_xticks([-1, 0, 1])\n",
    "ax.set_yticks([-1, 0, 1])\n",
    "\n",
    "# Set tick labels fontweight to bold and increase font size\n",
    "ax.tick_params(axis='both', which='major', labelsize=20, width=2, length=10)\n",
    "\n",
    "# # Set the fontweight for tick labels to bold\n",
    "# for tick in ax.get_xticklabels() + ax.get_yticklabels():\n",
    "#     tick.set_weight('bold')\n",
    "\n",
    "# Set the spines linewidth to bold\n",
    "ax.spines['top'].set_linewidth(2)\n",
    "ax.spines['right'].set_linewidth(2)\n",
    "ax.spines['bottom'].set_linewidth(2)\n",
    "ax.spines['left'].set_linewidth(2)\n",
    "\n",
    "# Set the legend\n",
    "# ax.legend()\n",
    "\n",
    "plt.savefig('LEM_0.81_20.pdf', dpi=500, bbox_inches=\"tight\")\n",
    "\n",
    "# Show the plot\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acd9f6c3",
   "metadata": {},
   "source": [
    "### 80-20 (80 for PINN and 20 extrapolation using LEM)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "11b46593",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "findfont: Font family ['Times New Roman'] not found. Falling back to DejaVu Sans.\n",
      "findfont: Font family ['Times New Roman'] not found. Falling back to DejaVu Sans.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.ticker import FixedLocator\n",
    "\n",
    "# Assuming you have defined concatenated_tensor as a PyTorch tensor\n",
    "# concatenated_tensor = torch.cat((tensor1, tensor2), dim=0)\n",
    "\n",
    "# Convert concatenated_tensor to a NumPy array\n",
    "concatenated_array = concatenated_tensor.numpy()\n",
    "\n",
    "# Define custom color levels\n",
    "x = np.linspace(0, 1, concatenated_array.shape[1])  # Replace 0 and 1 with your actual x range\n",
    "t = np.linspace(0, 1, concatenated_array.shape[0])  # Replace 0 and 1 with your actual t range\n",
    "X, T = np.meshgrid(x, t1)\n",
    "\n",
    "# Define custom color levels using the minimum and maximum from the NumPy array\n",
    "c_levels = np.linspace(np.min(concatenated_array), np.max(concatenated_array), 400)\n",
    "\n",
    "# Plot the contour with interpolated data\n",
    "plt.figure(figsize=(20, 5))\n",
    "plt.pcolormesh(T, X, concatenated_array, shading='auto', cmap='coolwarm')\n",
    "\n",
    "# Set the fontweight for axis labels to regular (not bold)\n",
    "plt.xlabel(\"$t$\", fontsize=26)\n",
    "plt.ylabel(\"$x$\", fontsize=26)\n",
    "plt.title(\"$u(x, t)$\", fontsize=26)\n",
    "\n",
    "# Set tick labels fontweight to regular (not bold) and increase font size\n",
    "plt.tick_params(axis='both', which='major', labelsize=20, width=3, length=10)\n",
    "\n",
    "# Set the fontweight for tick labels to regular (not bold)\n",
    "for tick in plt.gca().get_xticklabels() + plt.gca().get_yticklabels():\n",
    "    tick.set_weight('normal')\n",
    "\n",
    "# Set the number of ticks for x-axis and y-axis to 5\n",
    "num_ticks = 5\n",
    "x_ticks = np.linspace(np.min(T), np.max(T), num_ticks)\n",
    "y_ticks = np.linspace(np.min(X), np.max(X), num_ticks)\n",
    "\n",
    "plt.gca().xaxis.set_major_locator(FixedLocator(x_ticks))\n",
    "plt.gca().yaxis.set_major_locator(FixedLocator(y_ticks))\n",
    "\n",
    "cbar1 = plt.colorbar()\n",
    "# Set the number of ticks for the color bar with uniformly distributed numbers\n",
    "num_ticks = 5\n",
    "c_ticks = np.linspace(np.min(concatenated_array), np.max(concatenated_array), num_ticks)\n",
    "cbar1.set_ticks(c_ticks)\n",
    "\n",
    "# Set the fontweight and fontsize for color bar tick labels\n",
    "for t in cbar1.ax.get_yticklabels():\n",
    "    t.set_weight('normal')\n",
    "    t.set_fontsize(26)  # Increase the font size for color bar tick labels\n",
    "\n",
    "# Increase the size of numbers on axis and color bar\n",
    "plt.xticks(fontsize=26)\n",
    "plt.yticks(fontsize=26)\n",
    "\n",
    "# Increase the tick size and width of the color bar\n",
    "cbar1.ax.tick_params(axis='both', which='major', labelsize=30, width=3,  length=10)\n",
    "\n",
    "# Add a dotted line at t = 0.8\n",
    "plt.axvline(x=0.8, color='black', linestyle='dotted', linewidth=5)\n",
    "\n",
    "#plt.savefig('Contour_LEM_20.pdf', dpi=500, bbox_inches=\"tight\")\n",
    "plt.savefig('contour_LEM_20.jpeg', dpi=500, bbox_inches=\"tight\")\n",
    "# Show the plot\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e98c486",
   "metadata": {},
   "source": [
    "### exact solution contour"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "40d9dede",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.ticker import FixedLocator\n",
    "\n",
    "# Assuming you have defined concatenated_tensor as a PyTorch tensor\n",
    "# concatenated_tensor = torch.cat((tensor1, tensor2), dim=0)\n",
    "\n",
    "# Convert concatenated_tensor to a NumPy array\n",
    "concatenated_array = u\n",
    "\n",
    "# Define custom color levels\n",
    "x = np.linspace(0, 1, concatenated_array.shape[1])  # Replace 0 and 1 with your actual x range\n",
    "t = np.linspace(0, 1, concatenated_array.shape[0])  # Replace 0 and 1 with your actual t range\n",
    "X, T = np.meshgrid(x, t)\n",
    "\n",
    "# Define custom color levels using the minimum and maximum from the NumPy array\n",
    "c_levels = np.linspace(np.min(concatenated_array), np.max(concatenated_array), 400)\n",
    "\n",
    "# Plot the contour with interpolated data\n",
    "plt.figure(figsize=(20, 5))\n",
    "plt.pcolormesh(T, X, concatenated_array, shading='auto', cmap='coolwarm')\n",
    "\n",
    "# Set the fontweight for axis labels to regular (not bold)\n",
    "plt.xlabel(\"$t$\", fontsize=26)\n",
    "plt.ylabel(\"$x$\", fontsize=26)\n",
    "plt.title(\"$u(x, t)$\", fontsize=26)\n",
    "\n",
    "# Set tick labels fontweight to regular (not bold) and increase font size\n",
    "plt.tick_params(axis='both', which='major', labelsize=20, width=3, length=10)\n",
    "\n",
    "# Set the fontweight for tick labels to regular (not bold)\n",
    "for tick in plt.gca().get_xticklabels() + plt.gca().get_yticklabels():\n",
    "    tick.set_weight('normal')\n",
    "\n",
    "# Set the number of ticks for x-axis and y-axis to 5\n",
    "num_ticks = 5\n",
    "x_ticks = np.linspace(np.min(T), np.max(T), num_ticks)\n",
    "y_ticks = np.linspace(np.min(X), np.max(X), num_ticks)\n",
    "\n",
    "plt.gca().xaxis.set_major_locator(FixedLocator(x_ticks))\n",
    "plt.gca().yaxis.set_major_locator(FixedLocator(y_ticks))\n",
    "\n",
    "cbar1 = plt.colorbar()\n",
    "# Set the number of ticks for the color bar with uniformly distributed numbers\n",
    "num_ticks = 5\n",
    "c_ticks = np.linspace(np.min(concatenated_array), np.max(concatenated_array), num_ticks)\n",
    "cbar1.set_ticks(c_ticks)\n",
    "\n",
    "# Set the fontweight and fontsize for color bar tick labels\n",
    "for t in cbar1.ax.get_yticklabels():\n",
    "    t.set_weight('normal')\n",
    "    t.set_fontsize(26)  # Increase the font size for color bar tick labels\n",
    "\n",
    "# Increase the size of numbers on axis and color bar\n",
    "plt.xticks(fontsize=26)\n",
    "plt.yticks(fontsize=26)\n",
    "\n",
    "# Increase the tick size and width of the color bar\n",
    "cbar1.ax.tick_params(axis='both', which='major', labelsize=30, width=3,  length=10)\n",
    "\n",
    "#plt.savefig('Contour_Exact.pdf', dpi=500, bbox_inches=\"tight\")\n",
    "plt.savefig('contour_exact.jpeg', dpi=500, bbox_inches=\"tight\")\n",
    "# Show the plot\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6627cf46",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
